home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / lib / gcc-lib / ppc-amigaos / 2.95.1 / sys-include / powerup / ppcpragmas / cybergraphics_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-03-13  |  18KB  |  531 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_CYBERGRAPHICS_H
  4. #define _PPCPRAGMA_CYBERGRAPHICS_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__CYBERGRAPHICS_H
  7. #include <powerup/ppcinline/cybergraphics.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef CYBERGRAPHICS_BASE_NAME
  24. #define CYBERGRAPHICS_BASE_NAME CyberGfxBase
  25. #endif /* !CYBERGRAPHICS_BASE_NAME */
  26.  
  27. #define    AllocCModeListTagList(ModeListTags)    _AllocCModeListTagList(CYBERGRAPHICS_BASE_NAME, ModeListTags)
  28.  
  29. static __inline struct List *
  30. _AllocCModeListTagList(void *CyberGfxBase, struct TagItem *ModeListTags)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a1        =(ULONG) ModeListTags;
  40.     MyCaos.caos_Un.Offset    =    (-72);
  41.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  42.     return((struct List *)PPCCallOS(&MyCaos));
  43. }
  44.  
  45. #ifndef NO_PPCINLINE_STDARG
  46. #define AllocCModeListTags(tags...) \
  47.     ({ULONG _tags[] = { tags }; AllocCModeListTagList((struct TagItem *)_tags);})
  48. #endif /* !NO_PPCINLINE_STDARG */
  49.  
  50. #define    BestCModeIDTagList(BestModeIDTags)    _BestCModeIDTagList(CYBERGRAPHICS_BASE_NAME, BestModeIDTags)
  51.  
  52. static __inline ULONG
  53. _BestCModeIDTagList(void *CyberGfxBase, struct TagItem *BestModeIDTags)
  54. {
  55. struct Caos    MyCaos;
  56.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  57. //    MyCaos.M68kStart    =    NULL;
  58. //    MyCaos.M68kSize        =    0;
  59.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  60. //    MyCaos.PPCStart        =    NULL;
  61. //    MyCaos.PPCSize        =    0;
  62.     MyCaos.a0        =(ULONG) BestModeIDTags;
  63.     MyCaos.caos_Un.Offset    =    (-60);
  64.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  65.     return((ULONG)PPCCallOS(&MyCaos));
  66. }
  67.  
  68. #ifndef NO_PPCINLINE_STDARG
  69. #define BestCModeIDTags(tags...) \
  70.     ({ULONG _tags[] = { tags }; BestCModeIDTagList((struct TagItem *)_tags);})
  71. #endif /* !NO_PPCINLINE_STDARG */
  72.  
  73. #define    CModeRequestTagList(ModeRequest, ModeRequestTags)    _CModeRequestTagList(CYBERGRAPHICS_BASE_NAME, ModeRequest, ModeRequestTags)
  74.  
  75. static __inline ULONG
  76. _CModeRequestTagList(void *CyberGfxBase, APTR ModeRequest, struct TagItem *ModeRequestTags)
  77. {
  78. struct Caos    MyCaos;
  79.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  80. //    MyCaos.M68kStart    =    NULL;
  81. //    MyCaos.M68kSize        =    0;
  82.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  83. //    MyCaos.PPCStart        =    NULL;
  84. //    MyCaos.PPCSize        =    0;
  85.     MyCaos.a0        =(ULONG) ModeRequest;
  86.     MyCaos.a1        =(ULONG) ModeRequestTags;
  87.     MyCaos.caos_Un.Offset    =    (-66);
  88.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  89.     return((ULONG)PPCCallOS(&MyCaos));
  90. }
  91.  
  92. #ifndef NO_PPCINLINE_STDARG
  93. #define CModeRequestTags(a0, tags...) \
  94.     ({ULONG _tags[] = { tags }; CModeRequestTagList((a0), (struct TagItem *)_tags);})
  95. #endif /* !NO_PPCINLINE_STDARG */
  96.  
  97. #define    CVideoCtrlTagList(ViewPort, TagList)    _CVideoCtrlTagList(CYBERGRAPHICS_BASE_NAME, ViewPort, TagList)
  98.  
  99. static __inline void
  100. _CVideoCtrlTagList(void *CyberGfxBase, struct ViewPort *ViewPort, struct TagItem *TagList)
  101. {
  102. struct Caos    MyCaos;
  103.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  104. //    MyCaos.M68kStart    =    NULL;
  105. //    MyCaos.M68kSize        =    0;
  106.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  107. //    MyCaos.PPCStart        =    NULL;
  108. //    MyCaos.PPCSize        =    0;
  109.     MyCaos.a0        =(ULONG) ViewPort;
  110.     MyCaos.a1        =(ULONG) TagList;
  111.     MyCaos.caos_Un.Offset    =    (-162);
  112.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  113.     PPCCallOS(&MyCaos);
  114. }
  115.  
  116. #ifndef NO_PPCINLINE_STDARG
  117. #define CVideoCtrlTags(a0, tags...) \
  118.     ({ULONG _tags[] = { tags }; CVideoCtrlTagList((a0), (struct TagItem *)_tags);})
  119. #endif /* !NO_PPCINLINE_STDARG */
  120.  
  121. #define    DoCDrawMethodTagList(Hook, RastPort, TagList)    _DoCDrawMethodTagList(CYBERGRAPHICS_BASE_NAME, Hook, RastPort, TagList)
  122.  
  123. static __inline void
  124. _DoCDrawMethodTagList(void *CyberGfxBase, struct Hook *Hook, struct RastPort *RastPort, struct TagItem *TagList)
  125. {
  126. struct Caos    MyCaos;
  127.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  128. //    MyCaos.M68kStart    =    NULL;
  129. //    MyCaos.M68kSize        =    0;
  130.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  131. //    MyCaos.PPCStart        =    NULL;
  132. //    MyCaos.PPCSize        =    0;
  133.     MyCaos.a0        =(ULONG) Hook;
  134.     MyCaos.a1        =(ULONG) RastPort;
  135.     MyCaos.a2        =(ULONG) TagList;
  136.     MyCaos.caos_Un.Offset    =    (-156);
  137.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  138.     PPCCallOS(&MyCaos);
  139. }
  140.  
  141. #ifndef NO_PPCINLINE_STDARG
  142. #define DoCDrawMethodTags(a0, a1, tags...) \
  143.     ({ULONG _tags[] = { tags }; DoCDrawMethodTagList((a0), (a1), (struct TagItem *)_tags);})
  144. #endif /* !NO_PPCINLINE_STDARG */
  145.  
  146. #define    ExtractColor(RastPort, BitMap, Colour, SrcX, SrcY, Width, Height)    _ExtractColor(CYBERGRAPHICS_BASE_NAME, RastPort, BitMap, Colour, SrcX, SrcY, Width, Height)
  147.  
  148. static __inline ULONG
  149. _ExtractColor(void *CyberGfxBase, struct RastPort *RastPort, struct BitMap *BitMap, ULONG Colour, ULONG SrcX, ULONG SrcY, ULONG Width, ULONG Height)
  150. {
  151. struct Caos    MyCaos;
  152.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  153. //    MyCaos.M68kStart    =    NULL;
  154. //    MyCaos.M68kSize        =    0;
  155.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  156. //    MyCaos.PPCStart        =    NULL;
  157. //    MyCaos.PPCSize        =    0;
  158.     MyCaos.a0        =(ULONG) RastPort;
  159.     MyCaos.a1        =(ULONG) BitMap;
  160.     MyCaos.d0        =(ULONG) Colour;
  161.     MyCaos.d1        =(ULONG) SrcX;
  162.     MyCaos.d2        =(ULONG) SrcY;
  163.     MyCaos.d3        =(ULONG) Width;
  164.     MyCaos.d4        =(ULONG) Height;
  165.     MyCaos.caos_Un.Offset    =    (-186);
  166.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  167.     return((ULONG)PPCCallOS(&MyCaos));
  168. }
  169.  
  170. #define    FillPixelArray(RastPort, DestX, DestY, SizeX, SizeY, ARGB)    _FillPixelArray(CYBERGRAPHICS_BASE_NAME, RastPort, DestX, DestY, SizeX, SizeY, ARGB)
  171.  
  172. static __inline ULONG
  173. _FillPixelArray(void *CyberGfxBase, struct RastPort *RastPort, UWORD DestX, UWORD DestY, UWORD SizeX, UWORD SizeY, ULONG ARGB)
  174. {
  175. struct Caos    MyCaos;
  176.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  177. //    MyCaos.M68kStart    =    NULL;
  178. //    MyCaos.M68kSize        =    0;
  179.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  180. //    MyCaos.PPCStart        =    NULL;
  181. //    MyCaos.PPCSize        =    0;
  182.     MyCaos.a1        =(ULONG) RastPort;
  183.     MyCaos.d0        =(ULONG) DestX;
  184.     MyCaos.d1        =(ULONG) DestY;
  185.     MyCaos.d2        =(ULONG) SizeX;
  186.     MyCaos.d3        =(ULONG) SizeY;
  187.     MyCaos.d4        =(ULONG) ARGB;
  188.     MyCaos.caos_Un.Offset    =    (-150);
  189.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  190.     return((ULONG)PPCCallOS(&MyCaos));
  191. }
  192.  
  193. #define    FreeCModeList(ModeList)    _FreeCModeList(CYBERGRAPHICS_BASE_NAME, ModeList)
  194.  
  195. static __inline void
  196. _FreeCModeList(void *CyberGfxBase, struct List *ModeList)
  197. {
  198. struct Caos    MyCaos;
  199.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  200. //    MyCaos.M68kStart    =    NULL;
  201. //    MyCaos.M68kSize        =    0;
  202.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  203. //    MyCaos.PPCStart        =    NULL;
  204. //    MyCaos.PPCSize        =    0;
  205.     MyCaos.a0        =(ULONG) ModeList;
  206.     MyCaos.caos_Un.Offset    =    (-78);
  207.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  208.     PPCCallOS(&MyCaos);
  209. }
  210.  
  211. #define    GetCyberIDAttr(CyberIDAttr, CyberDisplayModeID)    _GetCyberIDAttr(CYBERGRAPHICS_BASE_NAME, CyberIDAttr, CyberDisplayModeID)
  212.  
  213. static __inline ULONG
  214. _GetCyberIDAttr(void *CyberGfxBase, ULONG CyberIDAttr, ULONG CyberDisplayModeID)
  215. {
  216. struct Caos    MyCaos;
  217.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  218. //    MyCaos.M68kStart    =    NULL;
  219. //    MyCaos.M68kSize        =    0;
  220.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  221. //    MyCaos.PPCStart        =    NULL;
  222. //    MyCaos.PPCSize        =    0;
  223.     MyCaos.d0        =(ULONG) CyberIDAttr;
  224.     MyCaos.d1        =(ULONG) CyberDisplayModeID;
  225.     MyCaos.caos_Un.Offset    =    (-102);
  226.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  227.     return((ULONG)PPCCallOS(&MyCaos));
  228. }
  229.  
  230. #define    GetCyberMapAttr(CyberGfxBitmap, CyberAttrTag)    _GetCyberMapAttr(CYBERGRAPHICS_BASE_NAME, CyberGfxBitmap, CyberAttrTag)
  231.  
  232. static __inline ULONG
  233. _GetCyberMapAttr(void *CyberGfxBase, struct BitMap *CyberGfxBitmap, ULONG CyberAttrTag)
  234. {
  235. struct Caos    MyCaos;
  236.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  237. //    MyCaos.M68kStart    =    NULL;
  238. //    MyCaos.M68kSize        =    0;
  239.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  240. //    MyCaos.PPCStart        =    NULL;
  241. //    MyCaos.PPCSize        =    0;
  242.     MyCaos.a0        =(ULONG) CyberGfxBitmap;
  243.     MyCaos.d0        =(ULONG) CyberAttrTag;
  244.     MyCaos.caos_Un.Offset    =    (-96);
  245.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  246.     return((ULONG)PPCCallOS(&MyCaos));
  247. }
  248.  
  249. #define    InvertPixelArray(RastPort, DestX, DestY, SizeX, SizeY)    _InvertPixelArray(CYBERGRAPHICS_BASE_NAME, RastPort, DestX, DestY, SizeX, SizeY)
  250.  
  251. static __inline ULONG
  252. _InvertPixelArray(void *CyberGfxBase, struct RastPort *RastPort, UWORD DestX, UWORD DestY, UWORD SizeX, UWORD SizeY)
  253. {
  254. struct Caos    MyCaos;
  255.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  256. //    MyCaos.M68kStart    =    NULL;
  257. //    MyCaos.M68kSize        =    0;
  258.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  259. //    MyCaos.PPCStart        =    NULL;
  260. //    MyCaos.PPCSize        =    0;
  261.     MyCaos.a1        =(ULONG) RastPort;
  262.     MyCaos.d0        =(ULONG) DestX;
  263.     MyCaos.d1        =(ULONG) DestY;
  264.     MyCaos.d2        =(ULONG) SizeX;
  265.     MyCaos.d3        =(ULONG) SizeY;
  266.     MyCaos.caos_Un.Offset    =    (-144);
  267.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  268.     return((ULONG)PPCCallOS(&MyCaos));
  269. }
  270.  
  271. #define    IsCyberModeID(displayID)    _IsCyberModeID(CYBERGRAPHICS_BASE_NAME, displayID)
  272.  
  273. static __inline BOOL
  274. _IsCyberModeID(void *CyberGfxBase, ULONG displayID)
  275. {
  276. struct Caos    MyCaos;
  277.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  278. //    MyCaos.M68kStart    =    NULL;
  279. //    MyCaos.M68kSize        =    0;
  280.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  281. //    MyCaos.PPCStart        =    NULL;
  282. //    MyCaos.PPCSize        =    0;
  283.     MyCaos.d0        =(ULONG) displayID;
  284.     MyCaos.caos_Un.Offset    =    (-54);
  285.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  286.     return((BOOL)PPCCallOS(&MyCaos));
  287. }
  288.  
  289. #define    LockBitMapTagList(BitMap, TagList)    _LockBitMapTagList(CYBERGRAPHICS_BASE_NAME, BitMap, TagList)
  290.  
  291. static __inline APTR
  292. _LockBitMapTagList(void *CyberGfxBase, APTR BitMap, struct TagItem *TagList)
  293. {
  294. struct Caos    MyCaos;
  295.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  296. //    MyCaos.M68kStart    =    NULL;
  297. //    MyCaos.M68kSize        =    0;
  298.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  299. //    MyCaos.PPCStart        =    NULL;
  300. //    MyCaos.PPCSize        =    0;
  301.     MyCaos.a0        =(ULONG) BitMap;
  302.     MyCaos.a1        =(ULONG) TagList;
  303.     MyCaos.caos_Un.Offset    =    (-168);
  304.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  305.     return((APTR)PPCCallOS(&MyCaos));
  306. }
  307.  
  308. #ifndef NO_PPCINLINE_STDARG
  309. #define LockBitMapTags(a0, tags...) \
  310.     ({ULONG _tags[] = { tags }; LockBitMapTagList((a0), (struct TagItem *)_tags);})
  311. #endif /* !NO_PPCINLINE_STDARG */
  312.  
  313. #define    MovePixelArray(SrcX, SrcY, RastPort, DestX, DestY, SizeX, SizeY)    _MovePixelArray(CYBERGRAPHICS_BASE_NAME, SrcX, SrcY, RastPort, DestX, DestY, SizeX, SizeY)
  314.  
  315. static __inline ULONG
  316. _MovePixelArray(void *CyberGfxBase, UWORD SrcX, UWORD SrcY, struct RastPort *RastPort, UWORD DestX, UWORD DestY, UWORD SizeX, UWORD SizeY)
  317. {
  318. struct Caos    MyCaos;
  319.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  320. //    MyCaos.M68kStart    =    NULL;
  321. //    MyCaos.M68kSize        =    0;
  322.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  323. //    MyCaos.PPCStart        =    NULL;
  324. //    MyCaos.PPCSize        =    0;
  325.     MyCaos.d0        =(ULONG) SrcX;
  326.     MyCaos.d1        =(ULONG) SrcY;
  327.     MyCaos.a1        =(ULONG) RastPort;
  328.     MyCaos.d2        =(ULONG) DestX;
  329.     MyCaos.d3        =(ULONG) DestY;
  330.     MyCaos.d4        =(ULONG) SizeX;
  331.     MyCaos.d5        =(ULONG) SizeY;
  332.     MyCaos.caos_Un.Offset    =    (-132);
  333.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  334.     return((ULONG)PPCCallOS(&MyCaos));
  335. }
  336.  
  337. #define    ReadPixelArray(destRect, destX, destY, destMod, RastPort, SrcX, SrcY, SizeX, SizeY, DestFormat)    _ReadPixelArray(CYBERGRAPHICS_BASE_NAME, destRect, destX, destY, destMod, RastPort, SrcX, SrcY, SizeX, SizeY, DestFormat)
  338.  
  339. static __inline ULONG
  340. _ReadPixelArray(void *CyberGfxBase, APTR destRect, UWORD destX, UWORD destY, UWORD destMod, struct RastPort *RastPort, UWORD SrcX, UWORD SrcY, UWORD SizeX, UWORD SizeY, UBYTE DestFormat)
  341. {
  342. struct Caos    MyCaos;
  343.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  344. //    MyCaos.M68kStart    =    NULL;
  345. //    MyCaos.M68kSize        =    0;
  346.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  347. //    MyCaos.PPCStart        =    NULL;
  348. //    MyCaos.PPCSize        =    0;
  349.     MyCaos.a0        =(ULONG) destRect;
  350.     MyCaos.d0        =(ULONG) destX;
  351.     MyCaos.d1        =(ULONG) destY;
  352.     MyCaos.d2        =(ULONG) destMod;
  353.     MyCaos.a1        =(ULONG) RastPort;
  354.     MyCaos.d3        =(ULONG) SrcX;
  355.     MyCaos.d4        =(ULONG) SrcY;
  356.     MyCaos.d5        =(ULONG) SizeX;
  357.     MyCaos.d6        =(ULONG) SizeY;
  358.     MyCaos.d7        =(ULONG) DestFormat;
  359.     MyCaos.caos_Un.Offset    =    (-120);
  360.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  361.     return((ULONG)PPCCallOS(&MyCaos));
  362. }
  363.  
  364. #define    ReadRGBPixel(RastPort, x, y)    _ReadRGBPixel(CYBERGRAPHICS_BASE_NAME, RastPort, x, y)
  365.  
  366. static __inline ULONG
  367. _ReadRGBPixel(void *CyberGfxBase, struct RastPort *RastPort, UWORD x, UWORD y)
  368. {
  369. struct Caos    MyCaos;
  370.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  371. //    MyCaos.M68kStart    =    NULL;
  372. //    MyCaos.M68kSize        =    0;
  373.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  374. //    MyCaos.PPCStart        =    NULL;
  375. //    MyCaos.PPCSize        =    0;
  376.     MyCaos.a1        =(ULONG) RastPort;
  377.     MyCaos.d0        =(ULONG) x;
  378.     MyCaos.d1        =(ULONG) y;
  379.     MyCaos.caos_Un.Offset    =    (-108);
  380.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  381.     return((ULONG)PPCCallOS(&MyCaos));
  382. }
  383.  
  384. #define    ScalePixelArray(srcRect, SrcW, SrcH, SrcMod, RastPort, DestX, DestY, DestW, DestH, SrcFormat)    _ScalePixelArray(CYBERGRAPHICS_BASE_NAME, srcRect, SrcW, SrcH, SrcMod, RastPort, DestX, DestY, DestW, DestH, SrcFormat)
  385.  
  386. static __inline LONG
  387. _ScalePixelArray(void *CyberGfxBase, APTR srcRect, UWORD SrcW, UWORD SrcH, UWORD SrcMod, struct RastPort *RastPort, UWORD DestX, UWORD DestY, UWORD DestW, UWORD DestH, UBYTE SrcFormat)
  388. {
  389. struct Caos    MyCaos;
  390.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  391. //    MyCaos.M68kStart    =    NULL;
  392. //    MyCaos.M68kSize        =    0;
  393.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  394. //    MyCaos.PPCStart        =    NULL;
  395. //    MyCaos.PPCSize        =    0;
  396.     MyCaos.a0        =(ULONG) srcRect;
  397.     MyCaos.d0        =(ULONG) SrcW;
  398.     MyCaos.d1        =(ULONG) SrcH;
  399.     MyCaos.d2        =(ULONG) SrcMod;
  400.     MyCaos.a1        =(ULONG) RastPort;
  401.     MyCaos.d3        =(ULONG) DestX;
  402.     MyCaos.d4        =(ULONG) DestY;
  403.     MyCaos.d5        =(ULONG) DestW;
  404.     MyCaos.d6        =(ULONG) DestH;
  405.     MyCaos.d7        =(ULONG) SrcFormat;
  406.     MyCaos.caos_Un.Offset    =    (-90);
  407.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  408.     return((LONG)PPCCallOS(&MyCaos));
  409. }
  410.  
  411. #define    UnLockBitMap(Handle)    _UnLockBitMap(CYBERGRAPHICS_BASE_NAME, Handle)
  412.  
  413. static __inline void
  414. _UnLockBitMap(void *CyberGfxBase, APTR Handle)
  415. {
  416. struct Caos    MyCaos;
  417.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  418. //    MyCaos.M68kStart    =    NULL;
  419. //    MyCaos.M68kSize        =    0;
  420.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  421. //    MyCaos.PPCStart        =    NULL;
  422. //    MyCaos.PPCSize        =    0;
  423.     MyCaos.a0        =(ULONG) Handle;
  424.     MyCaos.caos_Un.Offset    =    (-174);
  425.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  426.     PPCCallOS(&MyCaos);
  427. }
  428.  
  429. #define    UnLockBitMapTagList(Handle, TagList)    _UnLockBitMapTagList(CYBERGRAPHICS_BASE_NAME, Handle, TagList)
  430.  
  431. static __inline void
  432. _UnLockBitMapTagList(void *CyberGfxBase, APTR Handle, struct TagItem *TagList)
  433. {
  434. struct Caos    MyCaos;
  435.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  436. //    MyCaos.M68kStart    =    NULL;
  437. //    MyCaos.M68kSize        =    0;
  438.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  439. //    MyCaos.PPCStart        =    NULL;
  440. //    MyCaos.PPCSize        =    0;
  441.     MyCaos.a0        =(ULONG) Handle;
  442.     MyCaos.a1        =(ULONG) TagList;
  443.     MyCaos.caos_Un.Offset    =    (-180);
  444.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  445.     PPCCallOS(&MyCaos);
  446. }
  447.  
  448. #ifndef NO_PPCINLINE_STDARG
  449. #define UnLockBitMapTags(a0, tags...) \
  450.     ({ULONG _tags[] = { tags }; UnLockBitMapTagList((a0), (struct TagItem *)_tags);})
  451. #endif /* !NO_PPCINLINE_STDARG */
  452.  
  453. #define    WriteLUTPixelArray(srcRect, SrcX, SrcY, SrcMod, RastPort, ColorTab, DestX, DestY, SizeX, SizeY, CTFormat)    _WriteLUTPixelArray(CYBERGRAPHICS_BASE_NAME, srcRect, SrcX, SrcY, SrcMod, RastPort, ColorTab, DestX, DestY, SizeX, SizeY, CTFormat)
  454.  
  455. static __inline ULONG
  456. _WriteLUTPixelArray(void *CyberGfxBase, APTR srcRect, UWORD SrcX, UWORD SrcY, UWORD SrcMod, struct RastPort *RastPort, APTR ColorTab, UWORD DestX, UWORD DestY, UWORD SizeX, UWORD SizeY, UBYTE CTFormat)
  457. {
  458. struct Caos    MyCaos;
  459.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  460. //    MyCaos.M68kStart    =    NULL;
  461. //    MyCaos.M68kSize        =    0;
  462.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  463. //    MyCaos.PPCStart        =    NULL;
  464. //    MyCaos.PPCSize        =    0;
  465.     MyCaos.a0        =(ULONG) srcRect;
  466.     MyCaos.d0        =(ULONG) SrcX;
  467.     MyCaos.d1        =(ULONG) SrcY;
  468.     MyCaos.d2        =(ULONG) SrcMod;
  469.     MyCaos.a1        =(ULONG) RastPort;
  470.     MyCaos.a2        =(ULONG) ColorTab;
  471.     MyCaos.d3        =(ULONG) DestX;
  472.     MyCaos.d4        =(ULONG) DestY;
  473.     MyCaos.d5        =(ULONG) SizeX;
  474.     MyCaos.d6        =(ULONG) SizeY;
  475.     MyCaos.d7        =(ULONG) CTFormat;
  476.     MyCaos.caos_Un.Offset    =    (-198);
  477.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  478.     return((ULONG)PPCCallOS(&MyCaos));
  479. }
  480.  
  481. #define    WritePixelArray(srcRect, SrcX, SrcY, SrcMod, RastPort, DestX, DestY, SizeX, SizeY, SrcFormat)    _WritePixelArray(CYBERGRAPHICS_BASE_NAME, srcRect, SrcX, SrcY, SrcMod, RastPort, DestX, DestY, SizeX, SizeY, SrcFormat)
  482.  
  483. static __inline ULONG
  484. _WritePixelArray(void *CyberGfxBase, APTR srcRect, UWORD SrcX, UWORD SrcY, UWORD SrcMod, struct RastPort *RastPort, UWORD DestX, UWORD DestY, UWORD SizeX, UWORD SizeY, UBYTE SrcFormat)
  485. {
  486. struct Caos    MyCaos;
  487.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  488. //    MyCaos.M68kStart    =    NULL;
  489. //    MyCaos.M68kSize        =    0;
  490.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  491. //    MyCaos.PPCStart        =    NULL;
  492. //    MyCaos.PPCSize        =    0;
  493.     MyCaos.a0        =(ULONG) srcRect;
  494.     MyCaos.d0        =(ULONG) SrcX;
  495.     MyCaos.d1        =(ULONG) SrcY;
  496.     MyCaos.d2        =(ULONG) SrcMod;
  497.     MyCaos.a1        =(ULONG) RastPort;
  498.     MyCaos.d3        =(ULONG) DestX;
  499.     MyCaos.d4        =(ULONG) DestY;
  500.     MyCaos.d5        =(ULONG) SizeX;
  501.     MyCaos.d6        =(ULONG) SizeY;
  502.     MyCaos.d7        =(ULONG) SrcFormat;
  503.     MyCaos.caos_Un.Offset    =    (-126);
  504.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  505.     return((ULONG)PPCCallOS(&MyCaos));
  506. }
  507.  
  508. #define    WriteRGBPixel(RastPort, x, y, argb)    _WriteRGBPixel(CYBERGRAPHICS_BASE_NAME, RastPort, x, y, argb)
  509.  
  510. static __inline LONG
  511. _WriteRGBPixel(void *CyberGfxBase, struct RastPort *RastPort, UWORD x, UWORD y, ULONG argb)
  512. {
  513. struct Caos    MyCaos;
  514.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  515. //    MyCaos.M68kStart    =    NULL;
  516. //    MyCaos.M68kSize        =    0;
  517.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  518. //    MyCaos.PPCStart        =    NULL;
  519. //    MyCaos.PPCSize        =    0;
  520.     MyCaos.a1        =(ULONG) RastPort;
  521.     MyCaos.d0        =(ULONG) x;
  522.     MyCaos.d1        =(ULONG) y;
  523.     MyCaos.d2        =(ULONG) argb;
  524.     MyCaos.caos_Un.Offset    =    (-114);
  525.     MyCaos.a6        =(ULONG) CyberGfxBase;    
  526.     return((LONG)PPCCallOS(&MyCaos));
  527. }
  528.  
  529. #endif /* SASC Pragmas */
  530. #endif /* !_PPCPRAGMA_CYBERGRAPHICS_H */
  531.